Termination w.r.t. Q of the following Term Rewriting System could not be shown:
Q restricted rewrite system:
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
if(false, x, y) → mod(minus(x, y), y)
gcd(x, 0) → x
gcd(0, s(y)) → s(y)
gcd(s(x), s(y)) → gcd(mod(s(x), s(y)), mod(s(y), s(x)))
lt(x, 0) → false
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
Q is empty.
↳ QTRS
↳ Overlay + Local Confluence
Q restricted rewrite system:
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
if(false, x, y) → mod(minus(x, y), y)
gcd(x, 0) → x
gcd(0, s(y)) → s(y)
gcd(s(x), s(y)) → gcd(mod(s(x), s(y)), mod(s(y), s(x)))
lt(x, 0) → false
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
Q is empty.
The TRS is overlay and locally confluent. By [NOC] we can switch to innermost.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
Q restricted rewrite system:
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
if(false, x, y) → mod(minus(x, y), y)
gcd(x, 0) → x
gcd(0, s(y)) → s(y)
gcd(s(x), s(y)) → gcd(mod(s(x), s(y)), mod(s(y), s(x)))
lt(x, 0) → false
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:
MINUS(s(x), s(y)) → MINUS(x, y)
MOD(x, s(y)) → IF(lt(x, s(y)), x, s(y))
MOD(x, s(y)) → LT(x, s(y))
IF(false, x, y) → MOD(minus(x, y), y)
IF(false, x, y) → MINUS(x, y)
GCD(s(x), s(y)) → GCD(mod(s(x), s(y)), mod(s(y), s(x)))
GCD(s(x), s(y)) → MOD(s(x), s(y))
GCD(s(x), s(y)) → MOD(s(y), s(x))
LT(s(x), s(y)) → LT(x, y)
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
if(false, x, y) → mod(minus(x, y), y)
gcd(x, 0) → x
gcd(0, s(y)) → s(y)
gcd(s(x), s(y)) → gcd(mod(s(x), s(y)), mod(s(y), s(x)))
lt(x, 0) → false
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
MINUS(s(x), s(y)) → MINUS(x, y)
MOD(x, s(y)) → IF(lt(x, s(y)), x, s(y))
MOD(x, s(y)) → LT(x, s(y))
IF(false, x, y) → MOD(minus(x, y), y)
IF(false, x, y) → MINUS(x, y)
GCD(s(x), s(y)) → GCD(mod(s(x), s(y)), mod(s(y), s(x)))
GCD(s(x), s(y)) → MOD(s(x), s(y))
GCD(s(x), s(y)) → MOD(s(y), s(x))
LT(s(x), s(y)) → LT(x, y)
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
if(false, x, y) → mod(minus(x, y), y)
gcd(x, 0) → x
gcd(0, s(y)) → s(y)
gcd(s(x), s(y)) → gcd(mod(s(x), s(y)), mod(s(y), s(x)))
lt(x, 0) → false
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 4 SCCs with 4 less nodes.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
LT(s(x), s(y)) → LT(x, y)
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
if(false, x, y) → mod(minus(x, y), y)
gcd(x, 0) → x
gcd(0, s(y)) → s(y)
gcd(s(x), s(y)) → gcd(mod(s(x), s(y)), mod(s(y), s(x)))
lt(x, 0) → false
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
LT(s(x), s(y)) → LT(x, y)
R is empty.
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPSizeChangeProof
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
LT(s(x), s(y)) → LT(x, y)
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs:
- LT(s(x), s(y)) → LT(x, y)
The graph contains the following edges 1 > 1, 2 > 2
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
MINUS(s(x), s(y)) → MINUS(x, y)
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
if(false, x, y) → mod(minus(x, y), y)
gcd(x, 0) → x
gcd(0, s(y)) → s(y)
gcd(s(x), s(y)) → gcd(mod(s(x), s(y)), mod(s(y), s(x)))
lt(x, 0) → false
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
MINUS(s(x), s(y)) → MINUS(x, y)
R is empty.
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPSizeChangeProof
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
MINUS(s(x), s(y)) → MINUS(x, y)
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs:
- MINUS(s(x), s(y)) → MINUS(x, y)
The graph contains the following edges 1 > 1, 2 > 2
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
IF(false, x, y) → MOD(minus(x, y), y)
MOD(x, s(y)) → IF(lt(x, s(y)), x, s(y))
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
if(false, x, y) → mod(minus(x, y), y)
gcd(x, 0) → x
gcd(0, s(y)) → s(y)
gcd(s(x), s(y)) → gcd(mod(s(x), s(y)), mod(s(y), s(x)))
lt(x, 0) → false
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
IF(false, x, y) → MOD(minus(x, y), y)
MOD(x, s(y)) → IF(lt(x, s(y)), x, s(y))
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ Narrowing
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
IF(false, x, y) → MOD(minus(x, y), y)
MOD(x, s(y)) → IF(lt(x, s(y)), x, s(y))
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule IF(false, x, y) → MOD(minus(x, y), y) we obtained the following new rules [LPAR04]:
IF(false, z0, s(z1)) → MOD(minus(z0, s(z1)), s(z1))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ QDP
↳ Narrowing
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
MOD(x, s(y)) → IF(lt(x, s(y)), x, s(y))
IF(false, z0, s(z1)) → MOD(minus(z0, s(z1)), s(z1))
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule MOD(x, s(y)) → IF(lt(x, s(y)), x, s(y)) at position [0] we obtained the following new rules [LPAR04]:
MOD(s(x0), s(x1)) → IF(lt(x0, x1), s(x0), s(x1))
MOD(0, s(x0)) → IF(true, 0, s(x0))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
IF(false, x, y) → MOD(minus(x, y), y)
MOD(s(x0), s(x1)) → IF(lt(x0, x1), s(x0), s(x1))
MOD(0, s(x0)) → IF(true, 0, s(x0))
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
MOD(s(x0), s(x1)) → IF(lt(x0, x1), s(x0), s(x1))
IF(false, x, y) → MOD(minus(x, y), y)
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule IF(false, x, y) → MOD(minus(x, y), y) at position [0] we obtained the following new rules [LPAR04]:
IF(false, 0, x0) → MOD(0, x0)
IF(false, s(x0), s(x1)) → MOD(minus(x0, x1), s(x1))
IF(false, s(x0), 0) → MOD(s(x0), 0)
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
MOD(s(x0), s(x1)) → IF(lt(x0, x1), s(x0), s(x1))
IF(false, 0, x0) → MOD(0, x0)
IF(false, s(x0), s(x1)) → MOD(minus(x0, x1), s(x1))
IF(false, s(x0), 0) → MOD(s(x0), 0)
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ QDPOrderProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
IF(false, s(x0), s(x1)) → MOD(minus(x0, x1), s(x1))
MOD(s(x0), s(x1)) → IF(lt(x0, x1), s(x0), s(x1))
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
IF(false, s(x0), s(x1)) → MOD(minus(x0, x1), s(x1))
The remaining pairs can at least be oriented weakly.
MOD(s(x0), s(x1)) → IF(lt(x0, x1), s(x0), s(x1))
Used ordering: Polynomial interpretation [POLO]:
POL(0) = 0
POL(IF(x1, x2, x3)) = x2
POL(MOD(x1, x2)) = x1
POL(false) = 0
POL(lt(x1, x2)) = 0
POL(minus(x1, x2)) = x1
POL(s(x1)) = 1 + x1
POL(true) = 0
The following usable rules [FROCOS05] were oriented:
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
minus(0, x) → 0
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Instantiation
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
MOD(s(x0), s(x1)) → IF(lt(x0, x1), s(x0), s(x1))
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(mod(s(x), s(y)), mod(s(y), s(x)))
The TRS R consists of the following rules:
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
if(false, x, y) → mod(minus(x, y), y)
gcd(x, 0) → x
gcd(0, s(y)) → s(y)
gcd(s(x), s(y)) → gcd(mod(s(x), s(y)), mod(s(y), s(x)))
lt(x, 0) → false
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(mod(s(x), s(y)), mod(s(y), s(x)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(mod(s(x), s(y)), mod(s(y), s(x)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(x), s(y)) → GCD(mod(s(x), s(y)), mod(s(y), s(x))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(x), s(y)) → GCD(if(lt(s(x), s(y)), s(x), s(y)), mod(s(y), s(x)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(if(lt(s(x), s(y)), s(x), s(y)), mod(s(y), s(x)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(x), s(y)) → GCD(if(lt(s(x), s(y)), s(x), s(y)), mod(s(y), s(x))) at position [0,0] we obtained the following new rules [LPAR04]:
GCD(s(x), s(y)) → GCD(if(lt(x, y), s(x), s(y)), mod(s(y), s(x)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(if(lt(x, y), s(x), s(y)), mod(s(y), s(x)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(x), s(y)) → GCD(if(lt(x, y), s(x), s(y)), mod(s(y), s(x))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(x), s(y)) → GCD(if(lt(x, y), s(x), s(y)), if(lt(s(y), s(x)), s(y), s(x)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(if(lt(x, y), s(x), s(y)), if(lt(s(y), s(x)), s(y), s(x)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(x), s(y)) → GCD(if(lt(x, y), s(x), s(y)), if(lt(s(y), s(x)), s(y), s(x))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(x), s(y)) → GCD(if(lt(x, y), s(x), s(y)), if(lt(y, x), s(y), s(x)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(if(lt(x, y), s(x), s(y)), if(lt(y, x), s(y), s(x)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule GCD(s(x), s(y)) → GCD(if(lt(x, y), s(x), s(y)), if(lt(y, x), s(y), s(x))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(s(x1), s(x0)), s(s(x1)), s(s(x0))))
GCD(s(0), s(s(x0))) → GCD(if(true, s(0), s(s(x0))), if(lt(s(x0), 0), s(s(x0)), s(0)))
GCD(s(x0), s(0)) → GCD(if(false, s(x0), s(0)), if(lt(0, x0), s(0), s(x0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(s(x1), s(x0)), s(s(x1)), s(s(x0))))
GCD(s(0), s(s(x0))) → GCD(if(true, s(0), s(s(x0))), if(lt(s(x0), 0), s(s(x0)), s(0)))
GCD(s(x0), s(0)) → GCD(if(false, s(x0), s(0)), if(lt(0, x0), s(0), s(x0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(s(x1), s(x0)), s(s(x1)), s(s(x0)))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(if(true, s(0), s(s(x0))), if(lt(s(x0), 0), s(s(x0)), s(0)))
GCD(s(x0), s(0)) → GCD(if(false, s(x0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(if(true, s(0), s(s(x0))), if(lt(s(x0), 0), s(s(x0)), s(0))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(s(x0), 0), s(s(x0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(false, s(x0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(s(x0), 0), s(s(x0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(x0), s(0)) → GCD(if(false, s(x0), s(0)), if(lt(0, x0), s(0), s(x0))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(x0), s(0)) → GCD(mod(minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(s(x0), 0), s(s(x0)), s(0)))
GCD(s(x0), s(0)) → GCD(mod(minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(s(x0), 0), s(s(x0)), s(0))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(false, s(s(x0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(mod(minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(false, s(s(x0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(x0), s(0)) → GCD(mod(minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(x0), s(0)) → GCD(if(lt(minus(s(x0), s(0)), s(0)), minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(0), s(s(x0))) → GCD(s(0), if(false, s(s(x0)), s(0)))
GCD(s(x0), s(0)) → GCD(if(lt(minus(s(x0), s(0)), s(0)), minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(false, s(s(x0)), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), mod(minus(s(s(x0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(s(x0), s(0)), s(0)), minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), mod(minus(s(s(x0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(x0), s(0)) → GCD(if(lt(minus(s(x0), s(0)), s(0)), minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0))) at position [0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(0), s(s(x0))) → GCD(s(0), mod(minus(s(s(x0)), s(0)), s(0)))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), mod(minus(s(s(x0)), s(0)), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(s(x0)), s(0)), s(0)), minus(s(s(x0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(s(x0)), s(0)), s(0)), minus(s(s(x0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)), if(lt(0, x0), s(0), s(x0))) at position [0,1] we obtained the following new rules [LPAR04]:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(s(x0)), s(0)), s(0)), minus(s(s(x0)), s(0)), s(0)))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(s(x0)), s(0)), s(0)), minus(s(s(x0)), s(0)), s(0))) at position [1,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(x0), 0), s(0)), minus(s(s(x0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(x0), 0), s(0)), minus(s(s(x0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(x0), 0), s(0)), minus(s(s(x0)), s(0)), s(0))) at position [1,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(s(x0), s(0)), minus(s(s(x0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(s(x0), s(0)), minus(s(s(x0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(s(x0), s(0)), minus(s(s(x0)), s(0)), s(0))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(x0, 0), minus(s(s(x0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(x0, 0), minus(s(s(x0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(x0, 0), minus(s(s(x0)), s(0)), s(0))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(false, minus(s(s(x0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(false, minus(s(s(x0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(false, minus(s(s(x0)), s(0)), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), mod(minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), mod(minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), mod(minus(minus(s(s(x0)), s(0)), s(0)), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(minus(s(s(x0)), s(0)), s(0)), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(minus(s(s(x0)), s(0)), s(0)), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(minus(s(s(x0)), s(0)), s(0)), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0))) at position [1,0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0))) at position [1,0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0))) at position [1,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(s(x0)), s(0)), s(0)), s(0))) at position [1,1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0))) at position [1,1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0))) at position [1,1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0))))
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule GCD(s(s(x0)), s(s(x1))) → GCD(if(lt(x0, x1), s(s(x0)), s(s(x1))), if(lt(x1, x0), s(s(x1)), s(s(x0)))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(false, s(s(x0)), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(s(x0), 0), s(s(s(x0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(s(x1), s(x0)), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(false, s(s(x0)), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(s(x0), 0), s(s(s(x0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(s(x1), s(x0)), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(false, s(s(x0)), s(s(0)))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), mod(minus(s(s(x0)), s(s(0))), s(s(0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(s(x0), 0), s(s(s(x0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(s(x1), s(x0)), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), mod(minus(s(s(x0)), s(s(0))), s(s(0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(s(x0), 0), s(s(s(x0))), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(false, s(s(s(x0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(s(x1), s(x0)), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), mod(minus(s(s(x0)), s(s(0))), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(false, s(s(s(x0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(s(x1), s(x0)), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1))))) at position [0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), mod(minus(s(s(x0)), s(s(0))), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(false, s(s(s(x0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), mod(minus(s(s(x0)), s(s(0))), s(s(0)))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(s(s(x0)), s(s(0))), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(false, s(s(s(x0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(s(s(x0)), s(s(0))), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(false, s(s(s(x0))), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(mod(minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(s(s(x0)), s(s(0))), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(mod(minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(s(s(x0)), s(s(0))), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0)))) at position [1,0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(s(x0), s(0)), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(s(x0))), s(s(0))) → GCD(mod(minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(s(x0), s(0)), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(mod(minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(s(s(x0))), s(s(0))), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(s(x0), s(0)), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(s(s(x0))), s(s(0))), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(s(x0), s(0)), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0)))) at position [1,0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(s(s(x0))), s(s(0))), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(s(s(x0))), s(s(0))), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(s(x0)), s(0)), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(s(x0)), s(0)), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(s(s(x0)), s(s(0))), s(s(0)))) at position [1,1] we obtained the following new rules [LPAR04]:
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(s(x0), s(0)), s(s(0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(s(x0)), s(0)), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(s(x0), s(0)), s(s(0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(s(x0)), s(0)), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(x0), 0), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(s(x0), s(0)), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(x0), 0), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(s(x0), s(0)), s(s(0)))) at position [1,1] we obtained the following new rules [LPAR04]:
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(x0), 0), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(minus(s(x0), 0), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(s(x0), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(s(x0), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(s(x0), s(s(0))), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), minus(s(s(s(x0))), s(s(0))), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0,1] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), minus(s(s(x0)), s(0)), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), minus(s(s(x0)), s(0)), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), minus(s(s(x0)), s(0)), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0,1] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), minus(s(x0), 0), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), minus(s(x0), 0), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), minus(s(x0), 0), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [0,1] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), if(true, s(s(0)), s(s(s(x0)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), if(true, s(s(0)), s(s(s(x0))))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0)))
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule GCD(s(x0), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(lt(0, x0), s(0), s(x0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(s(x0), 0), s(0)), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
GCD(s(0), s(0)) → GCD(if(lt(minus(0, 0), s(0)), minus(0, 0), s(0)), if(false, s(0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(s(x0), 0), s(0)), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
GCD(s(0), s(0)) → GCD(if(lt(minus(0, 0), s(0)), minus(0, 0), s(0)), if(false, s(0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(s(x0), 0), s(0)), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0)))) at position [0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(lt(s(x0), s(0)), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(0), s(0)) → GCD(if(lt(minus(0, 0), s(0)), minus(0, 0), s(0)), if(false, s(0), s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(s(x0), s(0)), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(0)) → GCD(if(lt(minus(0, 0), s(0)), minus(0, 0), s(0)), if(false, s(0), s(0))) at position [0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(0)) → GCD(if(lt(0, s(0)), minus(0, 0), s(0)), if(false, s(0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(s(x0), s(0)), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
GCD(s(0), s(0)) → GCD(if(lt(0, s(0)), minus(0, 0), s(0)), if(false, s(0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(if(lt(s(x0), s(0)), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0)))) at position [0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(lt(x0, 0), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(0), s(0)) → GCD(if(lt(0, s(0)), minus(0, 0), s(0)), if(false, s(0), s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(x0, 0), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(0)) → GCD(if(lt(0, s(0)), minus(0, 0), s(0)), if(false, s(0), s(0))) at position [0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(0)) → GCD(if(true, minus(0, 0), s(0)), if(false, s(0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(x0, 0), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
GCD(s(0), s(0)) → GCD(if(true, minus(0, 0), s(0)), if(false, s(0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(if(lt(x0, 0), minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0)))) at position [0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(false, minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(0), s(0)) → GCD(if(true, minus(0, 0), s(0)), if(false, s(0), s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(false, minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(0)) → GCD(if(true, minus(0, 0), s(0)), if(false, s(0), s(0))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(0)) → GCD(minus(0, 0), if(false, s(0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(false, minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0))))
GCD(s(0), s(0)) → GCD(minus(0, 0), if(false, s(0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(if(false, minus(s(x0), 0), s(0)), if(true, s(0), s(s(x0)))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(mod(minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(0), s(0)) → GCD(minus(0, 0), if(false, s(0), s(0)))
GCD(s(s(x0)), s(0)) → GCD(mod(minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(0)) → GCD(minus(0, 0), if(false, s(0), s(0))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(0)) → GCD(0, if(false, s(0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(mod(minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
GCD(s(0), s(0)) → GCD(0, if(false, s(0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 1 less node.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule GCD(s(0), s(s(x0))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(minus(0, 0), s(0)), 0, s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), minus(s(x0), 0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), minus(0, 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), 0), s(0)), s(x0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(minus(0, 0), s(0)), 0, s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), minus(s(x0), 0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), minus(0, 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), 0), s(0)), s(x0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(0))) → GCD(s(0), if(lt(minus(0, 0), s(0)), 0, s(0))) at position [1,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), 0, s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), minus(s(x0), 0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), minus(0, 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), 0), s(0)), s(x0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), 0, s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), minus(s(x0), 0), s(0))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), minus(s(x0), 0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), minus(0, 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), 0), s(0)), s(x0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), 0, s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), minus(s(x0), 0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), minus(0, 0), s(0))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(0))) → GCD(s(0), if(true, minus(0, 0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), 0), s(0)), s(x0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), 0, s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), minus(s(x0), 0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(true, minus(0, 0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), 0), s(0)), s(x0), s(0))) at position [1,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), s(x0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), 0, s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), minus(s(x0), 0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(true, minus(0, 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), s(x0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(0))) → GCD(s(0), if(lt(0, s(0)), 0, s(0))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(0))) → GCD(s(0), if(true, 0, s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), minus(s(x0), 0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(true, minus(0, 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), s(x0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(true, 0, s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), minus(s(x0), 0), s(0))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, minus(s(x0), 0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(0))) → GCD(s(0), if(true, minus(0, 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), s(x0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(true, 0, s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, minus(s(x0), 0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(0))) → GCD(s(0), if(true, minus(0, 0), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(0))) → GCD(s(0), minus(0, 0))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), s(x0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(true, 0, s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, minus(s(x0), 0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), minus(0, 0))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), s(x0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), if(true, 0, s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, minus(s(x0), 0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(s(x0), s(0)), s(x0), s(0))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), s(x0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(0))) → GCD(s(0), if(true, 0, s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, minus(s(x0), 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), s(x0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(0))) → GCD(s(0), if(true, 0, s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(0))) → GCD(s(0), 0)
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, minus(s(x0), 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), s(x0), s(0)))
GCD(s(0), s(s(0))) → GCD(s(0), 0)
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, minus(s(x0), 0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), s(x0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, minus(s(x0), 0), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), mod(minus(minus(s(x0), 0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), s(x0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), mod(minus(minus(s(x0), 0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(x0, 0), s(x0), s(0))) at position [1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, s(x0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), mod(minus(minus(s(x0), 0), s(0)), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, s(x0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), mod(minus(minus(s(x0), 0), s(0)), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, s(x0), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(false, s(x0), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), mod(minus(s(x0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), mod(minus(s(x0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0))) at position [1,0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), mod(minus(s(x0), s(0)), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), mod(minus(s(x0), s(0)), s(0))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(s(x0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(s(x0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0))) at position [1,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(s(x0), s(0)), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(s(x0), s(0)), s(0)), minus(s(x0), s(0)), s(0))) at position [1,0,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0)))
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0))) at position [1,1,0] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0))) at position [1,1] we obtained the following new rules [LPAR04]:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
GCD(s(0), s(s(s(x0)))) → GCD(s(0), if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Matrix interpretation [MATRO]:
| POL(GCD(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(if(x1, x2, x3)) = | | · | x1 | + | | + | | · | x2 | + | | · | x3 |
| POL(lt(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(minus(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(mod(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
The following usable rules [FROCOS05] were oriented:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
P is empty.
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(mod(minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(mod(minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0)))) at position [0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(minus(s(x0), 0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0)))) at position [0,0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(s(x0), s(0)), s(0)), minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0)))) at position [0,0,0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(minus(s(x0), 0), s(0)), s(0)), if(true, s(0), s(s(x0)))) at position [0,1,0] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)), if(true, s(0), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(s(x0), s(0)), s(0)), if(true, s(0), s(s(x0)))) at position [0,1] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(true, s(0), s(s(x0))))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(true, s(0), s(s(x0))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), if(true, s(0), s(s(x0)))) at position [1] we obtained the following new rules [LPAR04]:
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), s(0))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), s(0))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), s(0))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
GCD(s(s(x0)), s(0)) → GCD(if(lt(minus(x0, 0), s(0)), minus(x0, 0), s(0)), s(0))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [POLO]:
POL(0) = 0
POL(GCD(x1, x2)) = x1
POL(false) = 0
POL(if(x1, x2, x3)) = x2
POL(lt(x1, x2)) = 0
POL(minus(x1, x2)) = x1
POL(mod(x1, x2)) = x1
POL(s(x1)) = 1 + x1
POL(true) = 0
The following usable rules [FROCOS05] were oriented:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
P is empty.
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
GCD(s(s(0)), s(s(x0))) → GCD(if(lt(0, x0), s(s(0)), s(s(x0))), if(lt(minus(x0, 0), s(s(0))), minus(x0, 0), s(s(0))))
The remaining pairs can at least be oriented weakly.
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
Used ordering: Matrix interpretation [MATRO]:
| POL(GCD(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(if(x1, x2, x3)) = | | · | x1 | + | | + | | · | x2 | + | | · | x3 |
| POL(lt(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(minus(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(mod(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
The following usable rules [FROCOS05] were oriented:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
GCD(s(s(s(x0))), s(s(0))) → GCD(if(lt(x0, s(0)), s(x0), s(s(0))), s(s(0)))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Matrix interpretation [MATRO]:
| POL(GCD(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(if(x1, x2, x3)) = | | · | x1 | + | | + | | · | x2 | + | | · | x3 |
| POL(lt(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(mod(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(minus(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
The following usable rules [FROCOS05] were oriented:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
P is empty.
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ MNOCProof
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [FROCOS05] to decrease Q to the empty set.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Narrowing
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ MNOCProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(s(s(x1))), s(s(s(x0)))) → GCD(if(lt(x1, x0), s(s(s(x1))), s(s(s(x0)))), if(lt(x0, x1), s(s(s(x0))), s(s(s(x1)))))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
Q is empty.
We have to consider all (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(mod(s(x), s(y)), mod(s(y), s(x)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
gcd(x0, 0)
gcd(0, s(x0))
gcd(s(x0), s(x1))
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ MNOCProof
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(mod(s(x), s(y)), mod(s(y), s(x)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
The set Q consists of the following terms:
minus(0, x0)
minus(s(x0), 0)
minus(s(x0), s(x1))
mod(x0, 0)
mod(x0, s(x1))
if(true, x0, x1)
if(false, x0, x1)
lt(x0, 0)
lt(0, s(x0))
lt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [FROCOS05] to decrease Q to the empty set.
↳ QTRS
↳ Overlay + Local Confluence
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ UsableRulesProof
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ MNOCProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x), s(y)) → GCD(mod(s(x), s(y)), mod(s(y), s(x)))
The TRS R consists of the following rules:
if(false, x, y) → mod(minus(x, y), y)
mod(x, s(y)) → if(lt(x, s(y)), x, s(y))
lt(0, s(x)) → true
lt(s(x), s(y)) → lt(x, y)
if(true, x, y) → x
minus(0, x) → 0
minus(s(x), 0) → s(x)
minus(s(x), s(y)) → minus(x, y)
mod(x, 0) → 0
lt(x, 0) → false
Q is empty.
We have to consider all (P,Q,R)-chains.